{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.INFO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-5-a34a30334354>:1: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "mnist = input_data.read_data_sets(\"./\", one_hot=True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcoAAAHRCAYAAADqjfmEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3hUxfrA8XdSCCWhK0qvoSlFxV5QwILYe0O9KAo2rop69frzcr2WawXERlGx14uKDSvYUBBRBOlFOkjvIWV+fyTMnFmzw2azm00238/z+PjOzuzZ0ZPdOWfmzIzSWgsAACheSqIrAABAeUZDCQCABw0lAAAeNJQAAHjQUAIA4EFDCQCABw0lAAAeFbqhVEpppdR2pdR9EZbvp5TaVvS+1vGuH0qG85l8ojinQ4rKa6VUWrzrh5KprN9RVZEXHFBKaRFpo7VeUJQ+RkQ+DilWQ0TO1Vq/E+59KB+KOZ/1ReQ9EWknIqkiMltEbtVaf+d7H8oP37lRSl0uIi+IyNVa69GB15uLyGIRSdda55VNTRGJ4s6nUipVRIaIyN9EJEtEFojI8VrrTb73VSRJdcWmtf5GRDL3pJVS3UVkvIh8kqg6oVS2SeGXb76IaBE5Q0TGK6X25Qe0YlNK1RGRf4jIrETXBaU2RESOFJEjRGSpiHQUkV0JrVGMVeiu1whcLiJva623J7oiKDmt9S6t9VytdYGIKBHJF5E6IlI3sTVDDDwgIsNFZF2iK4LoFV3wDJLCXoE/dKGZWmsayopAKVVdRM4VkbGJrgtKRyk1QwqvUN8XkdFa67UJrhJKQSl1qIgcIiLPJLouKLUDRSRPRM5VSq1WSs1TSl2X6ErFWlJ1vYY4RwqvVicluiIoHa11J6VUVRE5S0SqJLo+iF7ReNZTInKD1rpAKZXoKqF0GotILRHJFpEWItJGRL5QSs3TWn+W0JrFUNLeUUpht+uLuiI/rQSjqBv2NRG5QynVOdH1QdQGisgMrfXkRFcEMbGz6N//1lrv1FrPEJHXRaR3AusUc0nZUCqlmohIdxF5McFVQeyli0jLRFcCUeshImcVddOtlsKHQB5VSo1IcL0QnRlF/07qG5Jk7Xq9TES+11ovTHRFED2l1OFS+Dc6RQqnh9woIg1E5MdE1gulcoWIVA2k/ycib4vImITUBqWitV6olPpGRO5SSt0ohRexF4jIRYmtWWwla0PZV0QeTnQlUGoZUvhkZEsRyRWR30TkVK31yoTWClELzq0TEVFK7RaRLVrrzQmqEkrvIim80FkvImtF5G6t9ReJrVJsVfSu1xwRmaaUujf4ota6ndb6L1eoSqkrlVKbit5XUEZ1ROSc86m1nqS17qy1ztJa19VaH6e1/npPYc5nhVDsd3QPrXX3kMUG7hGRX4vel9TdeRXUX86n1nqF1vpkrXWm1rql1vrZPXnJ8h2t0CvzAAAQbxX9jhIAgLiioQQAwIOGEgAAD+9Tr71SzmMAM0E+K3grLkuWcE4TJx7nlPOZOHxHk0+4c8odJQAAHjSUAAB40FACAOBBQwkAgAcNJQAAHjSUAAB40FACAOBBQwkAgEeybrMFAEi0lFQTzhvV1cmaddJTJj7t8gEmTvtiWvzrVULcUQIA4EFDCQCABw0lAAAejFECAGIirVkTJz3vgXomXtx9dEjpKiba1MrG9b+IS9VKhTtKAAA8aCgBAPCg6xXlWmqHbBPPGVDHyZt/9tMmLhB3C78UsdvKPbWphYnHPtbbKVdvzOSY1BOorNJaNjfx73fVd/L+2t1qXb3sKBM3+GadifNjV7WY4Y4SAAAPGkoAADzoekXCpTVp7KR/v2c/E792wrMm7ppR4JQrCFznFYibF7wG7F97gYkb3v6KU+q5CceYOG/5isgrDUdK1aombvq1cvKeavSdiVOVPS+zd+9wyt1yUl8T589dICi/VLp9SnX2v+qaeHHP8F2tLT//m5Nu2/93Exfsmh/D2sUed5QAAHjQUAIA4EFDCQCAR4Ubo1x185FOWgVmBVRdbxMb27nv23+yfei46vgpcakbIrfooSNMPOeSJ5284FSP4DSPgpDrug931DLxlG0tw37WwTWWmPiczC1O3soJM038QUd3+gn8guOSK163U3A+aPRKccVFRKT7zDNNrB51pxJkLPyl1HVKa97UxHlLlpb6eCje3BGdTby456iw5VpPvMLEbfr+7OSFPlVQnnFHCQCABw0lAAAeMel6XXud2x26qVOuicedOCIWH2G0rzI1bN4unWfiWinVnLy1l2038crh7n/2Y6t7mXj9+TVNnLdsedT1hN95veyUgdBVddypHvZa7slNrZxyn53U0cS+qR3fnXahiU9/5mknLzh15APp5q80HAv+ZTfindPtybDl2nxxlYnbDphr4oLtS5xy7l9BZOaNdM/Zeyc+YeILXrjZyWv6r++j+ASIiCwYerib7vNUIGW/oy0/c6eAZPefZeJozm95wR0lAAAeNJQAAHjQUAIA4BH1GOW8UXZsYE7vYU5ehkoPpqL9iBJzP9e1b2qNQOzmvdjsaxNf+kZ3E2+8uKlTjsfNS+nQA014bT07Vvjhjv2cYsGpHjO3NDRxzuB9nHILH7InMvve6k5e/my7JFZwOlD6s+7Jzw0MnKy43R1rb/RfxrSC9BGdnfTXFz8cSNn//0vz3KXpsvvZKTgFubtLXY/cngebeFwv9xmIjoGl1VA6u0+2v/Hjzhzq5KUqOzXImQJy5a9OOV1QHvcCKTnuKAEA8KChBADAI+qu16ePf9HEoV2e/13fxsRrd2dFdfz/TbPdK03HK0/JyCzvYa8JHur9qpMXXK3l5eYTTXzpq92dchsvsLtcMHUkClN+M2H/cwaYOHXVBqeYO9VjtYlW3O6uvjP7ODsV4JRRVzt5qbNtvL6fXQUoV09zygWnojR75Q+3HqH1r+TW3O52m+6bartbd2qb13fQLU656rk/xrQe2/5uv68HVnF/e7bpHBO3eGu9k5ccnYBlp95di03cqUpVJ6/X7NNMnH2PPR/5SdLVGoo7SgAAPGgoAQDwiLrrdegF55r4n11qOnn7vmtX38hf73arRSpbwq/AE43W4208+rneTt7q1+0qMdfVXmbiYDesiEjb/ra7sPnddL2Whp5qu2Ej7eKsus5d22Pk5uYmrrJmm5O3aIh9gvWFy2wXbXCRdRGRaTn2WpGNm/36Z38bNu+sueeZuPq48F2tKs3+5Khq1cKWC5V/oO12f7z982HLdZ92pYn3nTUn4uPjr25s9HnYvC1j7TBU7fmTy6I6CcUdJQAAHjSUAAB40FACAOAR9RilnmZXha/nPnFf7h/DLpjhjl08/3gfE1835OnQ4sarl9oViO68+9DYV6yS2nmG+/9yQzv7Zxkcl6z3mzsO2b/WEhN3+cCd2nFohn1fcArI1Bz32vCf/ey0klRxN5ZF5LLSd5l4e0he7omHmLju3UtM/EbLT0vwCZOKffW7kPO5z4NltxJYMtp8qd0l5NiqdiPto2ac7ZSr/dIPZVan8oA7SgAAPGgoAQDwiMnGzUBprLzAXfFl9nG2+zs4nSN0g+dgXrCrNTQvOAXksrevd8q1/Cr5H22PlZGjTnPS195qFyR/saWdf3Xt9yc75cY0s+czTUJ2JCilK8Zf66TbTK5cXYKxtun00I7zQjvedzcuyNSL4leJlJC/kXKw2g93lAAAeNBQAgDgUSm7Xpff6e47WNB1a0Tva5BquwjzTjjYyUv7clpocUQp+JRq8FrOfd2f13/ZCSZe9g+7SD9drdHb3jj0/79VTdl9IMc2+zIk13al3bLaPuH80YRuTqnc/e33a8GJoyKqU/2fS79hAqz962wp9vVq68Of+2jlnGLP/7qr7R6mBzRY5ZTbeq7928pbtVoSgTtKAAA8aCgBAPCgoQQAwKPCjVGmtWzupBf029/ET104MqJjdK/qrsCSqiK7Xmiclmnikc8Pc/IGNjs6omPgrxq+UcVJn9fITkM4oOZKE19b73unXKPAxsGh13wLH2hv4mpfTYlBLZH97J9Oun3udRG9r/VLdgehgrkLTdwizx0vXvTgERKJgSuOMnHdV91nA3RoYXil7dfASY9q+0oglSmllVq7lonPnDzfybsga7iJa6WE30mm44hLTNz4HMYoAQAod2goAQDwKLddr9vOO8zEfx5k2/N/n/26U+7CrI1RHL301wc9Px/kpLPlp1Ifs7Kq9p7bNZrzno2nBc5V/24DnHJb77WriHx54BtO3tH/siu0/DqtiYnZnDl6+fMWOukWdywMUzLkfREeP21HZFM9fhrdxcT1c5nuUyrp6U6yaVrpulvXDnSn3p15zUQT96+1MqR0ZBt375NV/GpBZYk7SgAAPGgoAQDwoKEEAMAjoWOUqmtHE9ce4S5b9FFzu+NApNM33t1u+9dn7mwcttwHD3V30qk59qHyy/9td0H4a5+6VWV1eti8yiStifv/OW/Z8rh9lp76m5PODGxScd4kd2eLca0/MvEBV9mpO03/xRhleaU8g5l5gZHOOvNyyqA2lYPe6i7fOXJzQxP7fv9S69cz8bK/tTXxb4OeimHtCm3eWdXE+8b86JHhjhIAAA8aSgAAPMq06/WPIe6jw3dfaB/pvyRrvZO3NM+uJj9ndx0T3/DaVU656qvsI+X7T1xn4vzf54WtRy0Jv7nr/H8EVqoI6XpYnLvNxM3f2yaV1c4z7A4QwWkYIiIf/GG70/c/c3aZ1WnzI02ddMEztjs9t83OMqsHonflRRPC5p23wHatp078OWw5lEz+ps1O+rXldkeP/rXsPK2jbv/RKdftXrtx8/mZX8S0TkP+7OCkG95op4fkxfSTIscdJQAAHjSUAAB4lGnXa+1ua510sLu1x++nO3m5T+xn4uDKLc0l/Eocka4AEqrguK4mPrP2mECOex2xoSCwePcU9wnMZBd8uvWCBz428U9bmjvlyrK7Nbjg8rkPut12KcKGvuVd6j77OOk2GQvCll33dHMTZ0liFsauDHY9bzeZyHk418QP7zc95p+Vq+0vdodJ/Uyc/Q93GC7vj2Ux/+yS4o4SAAAPGkoAADxoKAEA8CjTMcp6/dwpFa1vtrtBtBrsjj2mydIyqZOIyMZsu/LDUVXDXzv0n3mpietL+OknyeiPi+30i+Bj449P7+mUayWxH8swDj3QSZ7y/Ne2TrXd8a2CwDVg+rzIdilA2dp8fCsnfVp1O868Tbur71RdlyuIv5qv2uleP/7Hrj52bNXiSu9dvi4w8SE/XezkVXnbTvtr+ZL9/U/UFBAf7igBAPCgoQQAwKNMu17zVrmPdbcaXD4e817frfib/dm7dzjprKdqFVuuMmj0lV08Of2mVBPf1OVLp9yYG041cb1ZbvdZ2pfTij12aodsJ72yR30TZ55q/0a+OvAFp1xwCkhByDVf9sfX2HjI98V+LhLr8iHvh81bnOuez/TPi//bQWK0+/YyE6uZWSZuMXyWU07n267XfbfOiX/F4oQ7SgAAPGgoAQDwoKEEAMAjoRs3J8pJM7c46XG1nwyk7DJ1l8+63ClX5+Op8axW+RZYsu+oGWeb+MsD33CKXXvHEyYukAInb8jag4s99Om1XnPSXTPs+1IC13Khxwte57V9+zonp8PDdtmr8vi4OUTqpYbfgeeRVSeFvLIpvpWBV4enBzrp5g/YZUV1nv2GRbuMaHnHHSUAAB40lAAAeFTKrtdza85w0tVTMk08L9duElp9RO0yq1NFUvvq3SYe8r7bnXp/A/v/Nlc7WXLvvr+YuEBsZuhOH8GpHmvy7abLT613N/7+dMRRJm4zxl3Zie7Wim13QereCyGu7mvZxcRNxJ1ipUMLJznuKAEA8KChBADAo9J0va4daLvtGqS6T68uzrVP3110/2AT1/84/CbRlVnesuUm/vW0Jk5e6/8W/2SriMjs7qNNfOyM803854aaYd/TeqjtRNVT3c2y63k28UbFNqr5B0764Ef/buJWt/wQWhyIK+4oAQDwoKEEAMCDhhIAAI+kHaNUGRlO+pxr7S4XWwt2O3m9p9gNpJs+y7hXSeQtX+GkW12yIkxJkT5ixy9rysJAHF5lewy9Mrnr9UucdLu+j9k43f3+SoE7hQgoS9xRAgDgQUMJAIBH0na9SoHbaffS+ONN/PGv3Z28pm/yuDlQ1pr9nzvMcfP/HRG2bCumAiGBuKMEAMCDhhIAAA8aSgAAPJJ2jFLnulNAmt/FGAcAoOS4owQAwIOGEgAAD6U1a58AABAOd5QAAHjQUAIA4EFDCQCABw0lAAAeFbqhVEpppdR2pdR9EZbvp5TaVvS+1vGuH0omivPZs+h8Fiilesa7fig5vqPJJYrzOaSovFZKVdh5+xW6oSzSWWt9156EUmqkUmpu0Y/nFcGCWusxWuvMMq8hSiL0fJ6glPpZKbVFKbVIKdV/T57W+vOi87k0ITVFpPiOJpfQ89lFKTVNKbWj6N9d9uRpre8RkY4JqWUMJUNDGepXERkoIj8nuiIoHaVUuoiME5FnRaSWiFwgIo8ppTontGIoLb6jSUIpVUVE3hORl0WkjoiMFZH3il5PGknXUGqtn9RafyEiuxJdF5RaXRGpKSIv6UJTRWS2iHRIbLVQGnxHk0p3KVwKdajWOkdrPVxElIickNBaxVjSNZRIHlrrNSLymohcqZRKVUodISLNROTbxNYMQJGOIjJDuyvXzJAk6G4NqrCDq6g0XhOR0SIyrCg9QGu9LIH1AWBlisjmkNc2i0hWAuoSN9xRotxSSrUTkTdEpK+IVJHCq9TblFKnJrRiAPbYJoXDI0E1RWRrAuoSNzSUKM8OEJG5WusJWusCrfVcEflQRE5JcL0AFJolIp2UUirwWqei15NG0jWUSqkqSqmqUjignK6UqqqUSrr/zkpiuoi0KZoiopRSrUSkjxQ+NYkKiu9oUpkoIvkicqNSKkMpdX3R618mrkqxl4x/nJ+KyE4ROVJERhbFxya0RoiK1nqhiPxNRIaLyBYRmSQi74jImETWC6XGdzRJaK13i8iZUjg8skkKv69nFr2eNCp6Q5kjItOUUvfueUFr3V1rrUL+mSgiopS6Uim1qeh9BYmpMjyKO59vaq0P0Fpnaa0ba61v11oXiIgopXoUnc8GUnhVi/KH72hyKe58TtdaH6y1rqa1PkhrPX1PnlLqHinsAcoRkQq7pyP7UQIA4FHR7ygBAIgrGkoAADy8Cw70SjmPftkE+azgLbX3UiXHOU2ceJxTzmfi8B1NPuHOKXeUAAB40FACAOBBQwkAgAcNJQAAHjSUAAB40FACAOBBQwkAgAcNJQAAHjSUAAB40FACAOBBQwkAgAcNJQAAHjSUAAB4eHcPqcgWv97JSX971NMmvrjvDU5e6lc/l0mdAIS38NHDTXzTyR87eR9ddISJC2bMKbM6IQKH29/axTe5m2/MO26siVtPvMLJa3XxL3GtVixxRwkAgAcNJQAAHknb9aqX1nDS9Y6pZuINbTOcvH2+KpMqIcZyTu1m4g1Xb3Pypnd7JaJjXLv8GBN/+3FnJ6/ls4tMnLdqdTRVhEdao4ZOesQZz5u4V7WdTt7Yw3qbuN6M+NYLe7d60JEmvv/650x8YrXtTrncwBbUww593ckbLu2KPfaaG4500g1ftV3t+es3lLiuscAdJQAAHjSUAAB4JG3Xa43lKmzefhf84aTzn4l3bRAtlV7FxPMe6+rkfXja4yZune52pxdEePxnGn9j33P1105elwP7mrjxOXS9xtrCa5o56dDuViSWyrDfqY3nH+TkfX3royaurqpIaS3/h+1unXrdUCfvzesam3j40HOcvH2emVzqz44Ed5QAAHjQUAIA4EFDCQCAR9KOUfrszEt30qXvYUe8zH2ii4nnnfaUk5ciVU1cIFoi0X9Zdyc9usmksGWHd7GPsz9a7zgTJ+oR9WTT5Kjlia4CPBb9y45Lzuo7IiQ3sl/NZza1NPGzL53q5DWS702cU88+VZCuUp1yl2StMnG3Ox5z8i6Tm00cz/FK7igBAPCgoQQAwCNpu15rnroqbN7md9wVQfaRP8KURFkITgERcbtbZ/UJdvm4XTKr8neY+Nhxtzp5LcftNnHGfDu1I3/deqdc1zcuMfG0bi87eT/vbG5ivTs3TO1RErv6HGriYS2fCMlNFyRWcEpIjQ4bS/z+j3dkOel3bjvRxI0+/D60eIllh/xWvP6PR0x8UtdBttw1U0v9WUHcUQIA4EFDCQCABw0lAAAeSTVGmd/dPs48vuOTTt4vu+34VoNXZjp5kS53hvhYdd0hTnreacGxK3vexmxu6pT739W9TNzmux/CHj/P89k5OeHHxcavsBvSVtu62HMURGpnPXs+D6zCmGSiqTS3CVj4b/sb+vshoVNCiheccrX2HHeMMmNFZGOFzT+0zxR0anaFkzftiDEmDp060iLNThGrOSd+f0/cUQIA4EFDCQCAR3J1vWbYdj9TubtJ5Gq7ckvB1q1lVifs3YD+7znpFLE7vzywvoOJJ5+e7ZRTS36J6PipNWuaePlVBzh5t3X6n4mn73Y74audRHdronyX417DZy3zdaAjWjk93R15fr80su7Wm1YeZeI1p9ouz/z1K6OqR+pXP5u46Vdu3ri5+5v4/My1UR2/tLijBADAg4YSAACPpOp6XXIW7X5FlB9yvRZc4Pyj+7ubOGtJ+CdbJcV9Gi7/uM4m7jPiCxNfW9vt1wl2854698yQg64I/3mISrtrZ0VUbujyXk66yiexXWmlMltzo90keeCAdyN6T7CrVURk8XH2O1uwI/k3CaBlAQDAg4YSAAAPGkoAADySaowyaz+mfSSb6qt3772QuGOSIiIfvzwqovedtaC3iVPO2eHk5Ud0BJTEwAbBMWIVttzcj9s46cbyZ5xqlPxSOrd30g/eaFe66VFtR2hxI7jiTnAKiEh8xyVV145Ounn6z2FKiizIzTFxrUXxm0LEHSUAAB40lAAAeCRV1ysqpvk7G7gv1FpiwudeHG7iB9f0dIpN/KO1iT85dLi4qploc8EuE3f78O9OqXa32OkKBdu3R1plxFmzd92uVrrBo3fMS27Xpa+7NWjquweauNH60m+6HKm5A6o76UMzdJiSIhO225W7qr03JW514o4SAAAPGkoAADwqfNdrSlW7H9nRjcIvYj1q7XGB1LY41gglNfu6Du4L7/xowv1TbRfqsIbfOcVSGtruoIJAV2uo458YbOLsh9wuJPYijb/gSjBt04P//6s65VbkB7oE8+hsLY111xxh4gF1Hg3JtRtGrMrf6eTc/Iddnarp/9aYON5nI61FMxNPOvnxkNzw3+1vN7QOpNbFtlIB3FECAOBBQwkAgAcNJQAAHhV/jLJ2LRM/0fDjsOUmfWs37G0lnl0oUCZyTu1m4mUXuitqpHhWbAlKVYHrPO2ONvaYdbaJGz5Udo+2QyS1wb5OuuvFv5m4ZkrV0OJG93G3mrjNfL6jpbHVDvlJZkpG2HKPrD3efd8xwXG++I35hZp7nd2cOfhcQqiNgaleIiKrh7UycQ3GKAEASAwaSgAAPCp812te8wZ7LyQiTT/JjXNNECqlUzsnvd9IuxHy6CbPmji4UXNhunh3rO7mpP835RATP91rrJM3pu3LJu57vu3Sy3yTLr24q1/HSY5u8kmxxbaEdKNlLea6vax98vkhTrqFTC67D1d2iEWnesoF3Lr8FCdd4+0fw5SMLf4yAQDwoKEEAMCDhhIAAI8KP0a57q5dxb7ee87pTrrKxF9NHH4tepTWuv526awJdz/i5NVypgaEnwJyy6rDTfzxl3YMJftxd4nC7FV2t4BHjr/EyQtu3HzhPXba0AdvuuNniL38GlUiKvdbrrtLxH5DmcZT1vb/LnFLBW6+5DATzzn/yYje8/137nKXZTXVjztKAAA8aCgBAPCo8F2vTx/wSiBlnzFeuaWmU65h3vIyqlHlsvXCw510sLu1VsgqLLNz7RSdx1f3MvHcoR2dcrXe/cXELXfZx9Xd9XtcqZN+ddLt3rzOxL+eN9TE40683imX/ulPnqMiGlmProqo3IDpbnd5Y5kVpiTipdmdc5z0mvGxPX5a40Ymnn9dUyfvx0uDu5qEXz3ota12CmD28xudvLLqOOaOEgAADxpKAAA8KlzXa1pz9/Y9S9kn5VJVellXp9Jb18l9ejXY3Tpue10n7/nzTzVxwS+/mzgr5Mm1aDZTTqnmdvN2PGiJiTMCfxcFaZEtuI6SSWvS2MTZmUvDlrtkSU8TN7tqpZPHVs1l7+jaC5z0u23sUEr+/EURHSO1fRsTz7+8vpM39NznTXxite0h7wzf3Ro09rozTJw2a1pE74k17igBAPCgoQQAwIOGEgAAjwo3RrlrtJvOTrdjU/mBzXsz33Snh6BsBDddvv2r85287F+mxvSzUuvXM3H1ce7Y4xstPwqkGJeMt9W9m5j4/X3fd/KCG2xv3GVX40nZ7T7qr9Ltij46d3esq1iptBltp+gM6d3FybtnHzv96sqay5y81Pftb+hvOxpLJLrUmGTiS7IimxoU6v3tdsWsWz+/0Mlr94OdNhTN8wuxwB0lAAAeNJQAAHhUiK7X1OxWJr6l+fthy1202K72UvP1stnQs7KrP8NdYn5jwU4TT+091Mnr9uwgE7f/vz9MnL9mbdjjpzVqaOLtnRs5eYOGvWbiU6tvdvKCXTRPbrJ/P9W+mRO2HOIjOCTyUbvA93eeW67N2wNtfBMbbJdG3qIlJp4w/Ggnb9AQ+/82dPWsvjXt5uoSjGNgh3a705/cYLuEv/6b3ZQ9+6cpTrny8B3ljhIAAA8aSgAAPGgoAQDwqBBjlLsb1TJxj2o5YcvNe6OtiRtoNoEtC1mvu2NJx7YebOJfBzzh5M3r84yJZ51o9wIZNP+CsMd/pb3dHSZ0PCU4FSV0HCO4+fOcG+xmr2rrr4LYq7rBnoGFeTudvFZp1Yp9z86QMavqq7huj4e6z0120v83oIeJr91nopPXPj22y4AGnw94adgpTl79kcF6zYzp58Yaf5kAAHjQUAIA4FEhul59rl1+jIkbvjbXxOxEkBh159j/889saunkdahqN8/uXooyhf8AACAASURBVNV2m37W8R3PEauGzXlmczMTP/5hHyevzd3TTax20d0ab5lv2elY5+832Mn75R9Pmfg/69qZ+J2RJzjlGo1guKQsLOy2y8R3tL7IzbtiPxOfdLLd1PzR/d0hlo4v2g3QlefHttWr601c//fJ4QuWc9xRAgDgQUMJAICH0lqHzeyVcl74TMTVZwVvxWUl70Se0+Cm2/MfrB223AMHvWvi77e2NvH4CYc55VrcWbG6cuJxTvmOJk4yfkcru3DnlDtKAAA8aCgBAPCgoQQAwKPCTw9BxZG3ZKmJW1y4NGy5kRKcVmJXfGkhFWtMEkBy4I4SAAAPGkoAADxoKAEA8KChBADAg4YSAAAPGkoAADxoKAEA8KChBADAg4YSAAAP7+4hAABUdtxRAgDgQUMJAIAHDSUAAB4VuqFUSmml1Hal1H0Rlu+nlNpW9L7W8a4fSiaK89mz6HwWKKV6xrt+KLkozumQovJaKcXuRuVMZf3NrdANZZHOWuu79iSUUqcppWYWnZzvlVId9uRprcdorTMTU01EKPR8nqCU+lkptUUptUgp1X9Pntb686LzGX7PLpQHoee0i1JqmlJqR9G/u+zJ01rfIyIdE1JLRMqcT6VUfaXUd0qp9UqpTUqpyUqpo/YUTJbf3GRoKA2lVBsReUVErhWR2iIyXkTe58q0YlJKpYvIOBF5VkRqicgFIvKYUqpzQiuGqCmlqojIeyLysojUEZGxIvJe0euoeLaJyN9EZB8pPJ//FZHxyfabm1QNpYicJCLfaK2/1VrnSeFJayQixyW2WohSXRGpKSIv6UJTRWS2iHTwvw3lWHcp3DB+qNY6R2s9XESUiJyQ0FohKlrrXVrruVrrAik8j/lS2GDWTWzNYivZGkpV9E9o+oDEVAelobVeIyKviciVSqlUpdQRItJMRL5NbM1QCh1FZIZ2J3DPELpbKzSl1AwR2SUi74vIaK312gRXKaaSraH8TESOU0p1L+rKuVNEqohI9cRWC6Xwmoj8n4jkiMg3InKX1npZYquEUsgUkc0hr20WkawE1AUxorXuJIW9PxdLEl7IJlVDqbWeIyKXi8gIEVklIvVF5HcRWZ7IeiE6Sql2IvKGiPSVwguejiJym1Lq1IRWDKWxTQp/UINqisjWBNQFMVTUDfuaiNyRbM8RJFVDKSKitX5ba32A1rqeiNwjhV11UxNcLUTnABGZq7WeoLUu0FrPFZEPReSUBNcL0ZslIp2UUsEhkk5FryM5pItIy0RXIpaSrqFUSh1cNJ61jxQ+LTm+6E4TFc90EWlTNEVEKaVaiUgfEfk1wfVC9CZK4QMfNyqlMpRS1xe9/mXiqoRoKaUOV0odrZSqopSqppS6XUQaiMiPia5bLCVdQykiw0Rkk4jMLfr31YmtDqKltV4ohY+eDxeRLSIySUTeEZExiawXoqe13i0iZ0phd/omKTy/Zxa9joonQ0SeFJH1IrJCRHqLyKla65UJrVWMVejdQ5RSu6TwIY/hWuu7Iyh/pYg8LiJVRaSD1npRnKuIEojifPaQwoYzQ0R6a62/inMVUUJRnNN7RORmKTynNbTW+XGuIkqgsv7mVuiGEgCAeEvGrlcAAGKGhhIAAA8aSgAAPLwL1/ZKOY8BzAT5rOAttfdSJcc5TZx4nFPOZ+LwHU0+4c4pd5QAAHjQUAIA4EFDCQCABw0lAAAeNJQAAHjQUAIA4EFDCQCABw0lAAAeNJQAAHjQUAIA4EFDCQCABw0lAAAe3kXRgURIa9bExJsOa2TiVX12O+UGHDTJxIPqzHPyDvj2ShMXLKlh4tZDfnXKFezYEb4e++9n4rxVq/dWbSCp5PU42MTrO2Y4eTv3teu269bbTXx750+dcv1q2e/NJzvcYwwe2c/EDR/6vnSVjTPuKAEA8KChBADAg65XJNzKwUc66buues3EZ2WuDfu+lMB1XoEUOHkzjh5jE0fbsPOum5xyze4J3+WT8Ua+ifOODVsMIiLKbuO3dsARTtaAG941cf9aK6M6/MjNDU387umHm7hgyXKnnM51u+dRMpsvtf9vv3xwuIkzlNtUFEjxW2amiLudY6625XpUc4c5vr3xURMfmXqLiRs/UP66YbmjBADAg4YSAACPCt/1mtK5vYnn3lzNxJd1+dEpd0PdKSbu8ehgJ2+/oeXvVj/ZpXbINnGwq1UkfHfrn/k5TvqPvOomzpd0J++QKrYLLjXQLfjrVcOcct222K7Y/R91/w6OrrvQxBOkZrF1qtRSUk247K7DTPzbtSPCviVH2+7slXnu+awa6LXbN7W6k9evpu1i7TfxbRMP29jaKfdFnwNMnLdkadh6oHhbztxm4nRlz29oV+vSvJ0mvmv56WGP9+OclvZ4Ndxu8W+PetrER55pn0Zf9pj7dKzOcf9OEoE7SgAAPGgoAQDwoKEEAMCjQoxRqgzbZ726/8FO3o932DGnrQW2D/zw1291yn3dxY5lHHfpVCdv7tCYVBMlMOeOTBOHjkkGz+PxP11t4gbDqjrlUif+HPb4666xUxT6DPzaxHfW/8Upl+8Ohzi+3dAqkPozfMFKasXgSMcl80zc+VU7JtzytslOudT2bUw85x9ZTt7ME54xcXCqwk11Frgf9oENP+/ewsnKX7c+bB1RqPnVK0w88BM7J2rmhv2ccnUCs6zy5y2UcLJlQ9i8w575u4nnnWbHK7vccoNTrvH9iX+GhDtKAAA8aCgBAPAot12vKVVtN9ucoZ1MvOA0t4vniU22u+atISebuNWbId062bYbbUarLk6ePs0+l562wz6+nvbFtJJWGxH63zFPB1Lu9drAP+zj5g3P+j2q49d/1p7/L9fapXnuHPFLccWLNfcT+7fVmK5XUWnuz0WVoyLryjzgf7YrrU1Id2tQ/uz5tlxfN++Y/rav76HbR5q4e9Vcp1ywK/aLrAPdg9D1ulf5GzeaePooO3xRe6E7RSN/Xvhhj0ilbi/+Pq1j77lOevP9pf6oUuOOEgAADxpKAAA8aCgBAPAoN2OUKdXdJatWvNrMxAu62UfDH9vYxik34YbjTJz51Q9hjx98hLn6xi1O3qDJE008erV9JHrzF3upNKJ2YBW75Fzo8lhT59nH+rOl9ONKWTPt+OK3u9wpJvVm5YUWN7QKm1UppTZt7KSnHvxaseWe2NTSSbd7xo575YcWjlD9kXZsc9zVh5i4e8PwY54onXqjE/P/tk99d3P1V6RxmJJlhztKAAA8aCgBAPBIaNdrsLt1zqMHOHnB7tZHNrQ18dend3DKpS4u+WPKy65wu297VJtg4g372OO9WLuTUy5/0+YSfxaKd/zMc0z82QFvOnlju4828X3iTuWJVF4Pu4LTPvfabveWae45rH/LYhNvf889hip+b9pKa8kFDcPmbdN2+sDr95/s5NX6PfyQSDQWXdHcxN+Nd3cJOirDbuA9v79b35Z321VndF74LnfER84p3Zz0Fb0mFlvu3bVdQ15J/NQs7igBAPCgoQQAwCOhXa9/XtLZxAtOf9LJ+3CHXTT76zM6mjhv8ZJSf+7uWuH71Gbvst01dLXGT+Yg+6f39NtuV3j/WvNMPO+pQ03c4b+rnHJrTrRPw512/SQnr29tu1h+w7TgyufuKugvthxv4j693cWY86rR95par66Jb7/8zbDl3t5qn1Su9Upsu1pD5c+yK7dcPqG/k7fgdDtkM7uv+5ty6juB5X5+mhmfylVyqTXdDc7XXGR/u68Z5I5tBDfjXhLYCHr9w+5i9lXpegUAoHyjoQQAwIOGEgAAjzIdo0xr5D6ufdvgV028In+Hk/fAPQNNXHNR6cc80lo2N3GfU34MXxBlIrhTxEvDTnHyBtxj8+acERhnOsM9RkrgOq9ACtxMKX5H5ttXH+Gkx39tV3lp99tyJ++ah+zOJRPudsdeKgsV2MXnkqy1npKJUXNOyE/Y6cWXExGZe639b8m+Kk4VSlIpXdxpeSu71zbxlrZ2qs3VR7nPCgyu95XnqHbpq54f3Wzi7PFToqxl/HBHCQCABw0lAAAeZdr1WlDP7b46p4ZdLPnf6w5z8mq+WvLu1uDGsisGHerk3XH1Gya+MDPxjxtXdjvPsOfnmGumxvz4/f7oZeI/b25q4pQZC5xyrXfYvzPWaoneVxvbBVKbElYPlEza/vs56csn2YXQT6q+2sTp4naHpqvUUn/20bfa4bXsN2L/GxBL3FECAOBBQwkAgEe52Y/y9JrTnfQH/W8ycfqO8CukbDjVrujwwZFPmbhVmttV8O52+5RW6/evdfKCq3lM3dAskLPSX2mUyIYr7ROn59/yqYkH1ZkXUjKy67dg90+HJ91VdZrc930gZbsCQ5+N9UlRJSmdnBZd1TyicjNft09FNpDvPSVRnug67nDYWTU2BFJV4vrZzqYDBdHuVFo2uKMEAMCDhhIAAA8aSgAAPMp2eshvc5109pv28eB55z/l5E25x135PxKf7Kxn4jNH/83Ja/rQNBO3a7vFfWNgNY/5U+0YZUvGKEslrVkTJ333nWNNfEr1rSYOXVVnQ77dBPj0GfY8vnjAC0651ul29Z20XaWqarEKNNeRu5rtTnQVEE+r3Klyh0272MRd97UbXX/z5YFOuWprlBRnZwP3eZJ/n/O6ic/JXOfk9b5zook/ku4mzno9vrvPRINfAgAAPGgoAQDwKNvpIdq9LW/9d3uLfeic65y8gt4bpTib1mY56ebv2LjKJ3Z1hyYhj6gHP1nPmOPk/WfdASa+9CS7qO/3t8X38ehklNq2tYkfmPCyk9c23U7nWJpnu1d7vzzYKdf6qT9MXHeFnTrS5yX3b2TOCaNtuZNCuskfD6wcEuWj52NePdnEjZnygCSUv9H9nd3ndJsObhHQQiZLNF56wq649sTz1Z28Lw+0q6VNujqwefubIav+lIOpI9xRAgDgQUMJAIAHDSUAAB7lZgm7+s+G9IE/W3y5fWPwWan16jrprtXtWOm0HS1i8AmV1/x7Mk0cHJMUEfl8px1f/td9N5q4+fPuuQ+3i0fry9xlDs+ZdKqJJ3R8y8k7fKBdAnHfEdGNLza+n3FJn1WBzdZrLi3/e6/UWMAzB2Utb5XdgSTzZDfvlqlHm/ijdu+a+PCrr3fK/aVtSADuKAEA8KChBADAo9x0vZYl3cjtwD21+jYT3/SN3eEiW34qszolixcOfy5s3sM3XWbiuh+Wvjtl4SctbcLtrZGrBo438fsj6gliLyvFdq3n1LRxtTh/bmp7O5Xg0qsnRPy+ZmMXmbj8dxTHTmqdOk5a77arLRVs317W1TE++bqriR+/0A5znHXdV065b56tWmZ1Coc7SgAAPGgoAQDwqJRdryt61Q2bl7YuvQxrknxSA2sgpYRch2WszwktXirNX7BdaS/3dRdgP6raAhN/WD/bxPnr1se0Dskua1bgSdGT3LxMZRelP+ImuyrW7BfjW6dGL9hVmG6uMz9sufZj3ZWcWv45NUzJ5JPWpLGJO7y3wsn74D07vNR0SHyf7FYZ9m9k6eCDnbzber8bWrywTlXWhbzSuNhyZYk7SgAAPGgoAQDwoKEEAMCjUo5R5tTRey+EqLy8/kgTd234rZO35O82bvlABxMX/PJ7VJ+l8+yuApvz3Z0J2lex14Brz7JjlPVGRT4tZeuFh5u4PG4mWxaavL7EJm4OX+7A6navidmyX8zrsehBO672ZqPHAjkZTrlRm+1YdevHFzh5+XmVZ1LI5kMbmfjBBu87eXde9Z2JD67/dyev7eiQTe0jsOi82ibOreNuwn5vz7dNfH6mOx6aInbz5+C7nrr3XKdcLUn8d487SgAAPGgoAQDwqJRdr4ifTz8/yCb6ul2vM44eY+KV79mpIo+u7eGU+/ibrhKJcWcPNXHoAuzTc+w14D6v/Gpit2PI79x/fmriCa/XLME7k4cOrNwybGNrJ++mOrZr86KspSa+78XeTrm2j9jF0wtCNk0PZ9t5hznp6Zc+buJqgWkpwa5WEZH3z7Fd//l/hp86kuxqrNhp4uDG9CIi/6w/08Rzz37KyUs5O9gdGpzqpZxywTzn/RGWExFZG1hU/6j3bjFx9tvu5gflYaCMO0oAADxoKAEA8KChBADAgzFKEUlV9nqhzqwEViQJtB660MQ/XuAuB3hYRq6JG6fZPSYeDZlG8ugFbjqcFLHHLwgZffx4ayebt2OHRGPU7KNM3FR+i+oYFV3+ps0m/qKPO9YlH9gwOF45v8dop9hLh9rpIv993X30P+iSs7+0ca1HnbxqqnpocREReeLlM5x049lsti0iIj/MMOHXNx/hZJ34DzvW/L92bzh5wWUJQ8cbg9ypHXYU8ZWt7s5M52ba5QY7fjLQyWs2zh6jzYc/mrg8jEmG4o4SAAAPGkoAADzoehWRfG277erM3uYpib3JX7PWxA+efI6TN3fgPibu3+MLEw+qG93KPP2WHm/iqRPcbsGWY5YGUsslGk3Pq5zdreHkLVnqpF8dFthO5KZAWMddEeeyrNU2vnpEhJ/mdrW+sKWhid859zgTN579o8Av7Ytp7gv2qyenn3aTk7XyIrup85Rj7NSRc+de6JRb94Hd0UMFRj0avuJO/xnb2XaNZ3/5U8R1Lm+4owQAwIOGEgAAD7pexX3qFbGTP2+hk249yKa/lBqBuFuUn2AXcG4q7tOOlWf568QJLjD/6Qv1Tfx58y5OuTnX2ychjz7UdrN/O6WDhNNu5EYnXTBvsYl17tySVxbFqjp+ipNuOd7GF4pd5ShN3G73/ULSe+SHpNO+3FCq+pUXtBAAAHjQUAIA4EFDCQCAB2OUIrIw104JSd1kV3EJ7W8HUDyda6cV5M9f5OS1ucmm1wRf92zIy3cP5Ql3lAAAeNBQAgDgUSm7Xpv/c7KTHvjPowMpd0oDAKBy444SAAAPGkoAADxoKAEA8KChBADAg4YSAAAPGkoAADyU1jrRdQAAoNzijhIAAA8aSgAAPGgoAQDwoKEEAMCjQjeUSimtlNqulLovwvL9lFLbit7XOt71Q8lwPpMP5zS5RHE+hxSV10qpCru2eIV+6lUppUWkjdZ6QeC1kSJynIi0EZG/aa1fiOR9SLzQ86KUyhaRh0XkSBFJFZGpInKj1nqu730oP4o5p8eIyMchxWqIyLla63fCvQ/lQ5jf3C4iMkZE2ovIbBHpp7X+JZDfXEQWi0i61jqvTCscIxX6jjKMX0VkoIj8nOiKoNRqi8j7ItJWRBqIyBQReS+hNUKpaK2/0Vpn7vlHRPqIyDYR+STBVUMUlFJVpPA7+bKI1BGRsSLyXtHrSSPpGkqt9ZNa6y9EZFei64LS0VpP0VqP0Vpv0FrnisjjItJWKVUv0XVDzFwuIm9rrbcnuiKISncp3K5xqNY6R2s9XESUiJyQ0FrFWNI1lEhqx4rIaq31+kRXBKWnlKouIudK4V0IKqaOIjJDu2N4M4peTxo0lKgQlFKNReRJEbk50XVBzJwjIutEZFKiK4KoZYrI5pDXNotIVgLqEjc0lCj3lFL7iMinIvKU1vq1RNcHMXO5iLyoK/IThdgmIjVDXqspIlsTUJe4oaFEuaaUqiOFjeT7WuuIHklH+aeUaiKF41svJrgqKJ1ZItJJKaUCr3Uqej1pJF1DqZSqopSqKoUDyulKqapKqaT776wMlFI1RWSCiHyntb4j0fVBTF0mIt9rrRcmuiIolYkiki8iNyqlMpRS1xe9/mXiqhR7ydiAfCoiO6Vw7t3IovjYhNYI0TpLRLqJyJVFk9D3/NM00RVDqfUVHuKp8LTWu0XkTCk8n5tE5G8icmbR60mjojeUOSIyTSl1754XtNbdtdYq5J+JIiJKqSuVUpuK3leQmCrDwzmfWuuxReevRnDundZ6qQjns4L4y3dURERr3U5rPSa0MOe03CvuN3e61vpgrXU1rfVBWuvpe/KUUvdI4dz2HBGpsGPRFXplHgAA4q2i31ECABBXNJQAAHh4V3PvlXIe/bIJ8lnBW2rvpUqOc5o48TinnM/E4TuafMKdU+4oAQDwoKEEAMCDhhIAAA8aSgAAPGgoAQDwoKEEAMCDhhIAAA8aSgAAPGgoAQDwoKEEAMCDhhIAAA8aSgAAPGgoAQDw8O4eUtHMH3uQief2HOXknXD9QBNXH/djmdUJACqL1I5tnfSSs+uZ+JDeM528F5t9beJcnR/R8XtcN8BJV3t3SkmrGBXuKAEA8KChBADAI6m6XkXbPTcLpMDJWtHDxm3GlVWFEJTWopmJl53VyMRbs/Occm2zV5h4fNv3TZz9wbVOucYT7HVezemrnTy9bYeJ8//808Qqzf2TX3njoSbOq+bWt+kj0+zxcnIEwF9tufhwE596x0Qnb1y938K+L1fb72/o73U4Tw8d5qQHz+1r4vzZ8yM6RjS4owQAwIOGEgAAj+TqevVo1X6liVVGhpNHt1p8rB50pJP+afATJo60qyVYal6fZ9y8PuGP8cbW/U383N/PMvHKY9w/+d8ud7tygk6beLWJ1Xe/7K2qQNJKqVrVSS/8V1cTz7pshIkj/V5HKzu9ipOefVMdm3dtaOnY4Y4SAAAPGkoAADxoKAEA8Kg0Y5QftXvXxGdk9nLy8hmjjJnU1i1MPPamx0NyS/7nNm7bviY+J3NdxO+7IGuVjUc/ZeKUkGvD4IjK9Bw3L3XzrmLLVSZrbrTjzFsO2eUpGV/pGXYK0cyjnw9brk+jg8uiOpWDstPtgmOSIiK/XTY8kCr9/VaHN28Im/f7+U+EzXvg+LdM/PyhfWzGlPDTUqLBHSUAAB40lAAAeFSarleUjZW97bSM9lXCX4ed8NsFJq5xb82w5dJXbTLxmIa1nbycevZR8YEPveXknZW5du+VFZGZu7WJB98y0MmrPpPF87cfblc4mn3cqLDlgl3a0U4RiPQYwZyXtzSJ6rNQvIJjbBfrov729d9PGF5M6b96e9t+Tvqf39qpWU3ed38Pqr1nFzRvLT+YWHXt6B70/PCfF/yeD29Zw8RZMV4rnTtKAAA8aCgBAPCgoQQAwIMxSsTU0ZdNC5u3Kn+nidf81sDEqaeEP16Dn+w45JpDUt3P6mkfAY90TDLUB1u6mJgNvf+qzcDFJj476ywnb/EVTU2cU8eOHCotUSmov9vEs3s+G7Zcu4/sWHL72xaE5G6M7sMrq8AUEJHQccmRER3itLmnm7jg7n2cvOzvfoq+buUId5QAAHjQUAIA4EHXK2Lqw586m/ih075x8pqmZZp49sUjJCJX2jBduV2vuTo/kHKv+dYFunmPeetWE0887xGn3J31bfdt9/Ovc/Iy3/xBKrv8TZttIhiLSJN7l8f0s7adbzcAlp5u3oJcuzJP+4c32PptpKu1pII7gYSuuBPpNJAfc9JNrE+wG60rWVFc8QqPO0oAADxoKAEA8KDrFTGVPcAuiXFQvX5O3m9HvWDiaFZvyQ15mvL97XbT1mGLezh5KcPqm7jVR7YL9ZgaNzvl5pz2pIlX9sp38rLfLHEVUQqr+uwOmzdkuV3wOn/ewrKoTtLS7VuZ2F3cPLz2X1zjpFuNtN/fFEn+Tc25owQAwIOGEgAADxpKAAA8GKNE3LQc4o45de94XZiS0an902oTV1u0OCQ3NL13B2Yvc9Js51225vcYbeKCkGv4aVPamLi1rC+zOiWjFT1qmTh0I/OgcdvrmrjNiFw3M8YbI/sE6/jXKWI21u4iQzGuAwAACIuGEgAAD7peETf5s+Y66cxZsT1+3t6L/EXb7PArh/w2z90EOFtWhymJeCgQHYjd6UPRLrQOkbQmjZ30yRdPNrFvmtbtX9rN1bOnxHgnZI/ld7vpYB1Dp4hdvsQu4VTnw99N7E70Kj3uKAEA8KChBADAI7m6XgP9M6FPc4U+LYXKI7fnwSae0NbdY29yYHHntk/tcPLo7YuvnWccGvJK+L1M8+vapy4XvWr3ED242VKn3KD9P7PvEfcxyKufu97ETf7zfUmqWqFtOMbtev1Pg3Fhy/aaeb6J2982x8Sx7soMteSNTiZ+rssLEb9v4TPtTFx7y2RPydLhjhIAAA8aSgAAPGgoAQDwSK4xysDSDKGPPQcfK559fysnL/uaDYLkkpKVZeL7R9pxydCx6q+32TEOPT3G81eSTGqDfZ301iNbmHhnXXvNnXL2uoiON7bj0JBXMsKWnXPiMxEds98fvUw87ZMOTl7zx+wuFyXfu6biWn/6jr0XKrJseT0TZ28p+epW0bqt06cmPiQj/Ihov6XHO+l6nywwcTzHUbmjBADAg4YSAACP5Op6jVSVytTxUjmk1qvrpLe9ahd+7poRfmWP5yYdZ+I28mN8KleB5Z54iImz7l7i5I1rOcLEwelYkW/Knb73IkWCXap/3tw0fMEfZpiwqbhTQCrrt/7OLp84ad9C6Nn9fop3dYwtH9shsL41g1ODwtfv9+c6Oul6f8ZvSkgQd5QAAHjQUAIA4EFDCQCAR+Uco0TSWdavnZP+6YBhxZb7z7pOTrr942tMHM1uJMnuj1PsT8SElhOcvFe2NjLxpvzqJn5vZWen3NqvGklxhvd71kn3qGYf8O/280VOXt0+8wKpTf5Kw5Gv3fuhyMeQSy+1tn1WYMEzzZy8WZ2ej6hOHd68wcStR5XNmGQo7igBAPCgoQQAwIOuV1QYwdV2RETWvNLQxO90fjikdBUTDd9ou2UnPHSMU6rWoh9iV8EkVHu2Xe0q+6Nrnbz2g213aP6mzSauIn845RqHpPf49WK3K+7YqvOjrifKh+BOPSIiDe6153Rc0zEhpYu/T/t8p/s9bzvKrpwW711MwuGOEgAADxpKAAA86HpFTK0edKSJq/R0F8d+tMObJi7QkV2j3bfkVBMPafGukxdccSfY1Rrqqwvs6jK1ZtHVWhL1R04OxG5ePLvB0l+uu/dCiLn1Vx1h4nqjI3vCdN7ztru1WaP1Tt6opl+UuA43E5sXwwAAA2hJREFUfHy5k27ze+JXzOKOEgAADxpKAAA8aCgBAPBgjBKlsvWCw530T4OfCFs2uGlyrs6N6PgftbPjkqGbLgd3AtlcsMvJ6/HIYBPvN8vdRQKJE9z8uWF68dNGRETSdlXWvT5i76EZJzrpvkc/H6akSId+dvPyn/a3zxv0v/Ajp9x1tReaOF3ZDbFzdejIdfh7seD3OXvs9SZu84/ErL7jwx0lAAAeNJQAAHhU+K5XlWb/EzJq7E5gTSqnVb3cpcR9ixsHu0qjWZg5dNPl4DH+b3UPJ6/Rp3+aOFGreeCvth7ZwsRnZX4Ykst1ezw0HulukD25m+3yPCzDHQJxpnNcG35qR/DbG+n3OrhClojIqPG2S7jlv342ccjXvFzgLxMAAA8aSgAAPGgoAQDwqPBjlCktmpr4lyOfC1suOH2g4UcV/j87oVLr2eXFLjp4SgJrYj3e8Bsn/dX4TBM/cXR3E+etXiMoH1JCrtOD39G0bYwsx0raF9Oc9K1DBpj4m/uHx/SzluflOOmH1vQy8bIrmjh5LX6300DK47hkEHeUAAB40FACAOBR8fsgN2wy4YEv3mjiQ46d4xRb/nAbE2e+m/jV6Cuy3A52w9179p0Q8+Of/Pu5Jl4zqZHNUG65Oy6xu5FckLXKyTu+2jYTP5ERfmcRJE7oVIIXNx9o4vTPp4UWR4zU/8SuqtO1yU1O3vQBw0p17LOG3eak938suCrWPKmouKMEAMCDhhIAAI8K3/Wav36DiVsEFtNdH1KumpSPpzOTQfoq29199PRLnLxvu74S9n2r8neauNdLdtHy1iOXO+UyVtpu1Ca54RfOfv2ZriZ+o/oRTt6WgxuaOGtLxe3yqUxGzT7KxE3ltwTWJLnlr1lr4ib/Wevknf6fbqU69v6SnBsQcEcJAIAHDSUAAB40lAAAeFT4MUqUvfwFi01ct4+bd7pENsbRXOx4cp6nnLcef/4ZNq/6H8tsuSiPj9hb0TN8XuZHmeEzgQTijhIAAA8aSgAAPOh6BVBmUnbZ5ZUeXX+Ak1f3+cmhxYFygTtKAAA8aCgBAPCgoQQAwIMxSgBlptUtP5h4klRLYE2AyHFHCQCABw0lAAAeSmud6DoAAFBucUcJAIAHDSUAAB40lAAAeNBQAgDgQUMJAIAHDSUAAB7/DxK8xwtogAslAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis('off')\n",
    "    plt.title('[{}]'.format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape((28, 28)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_image = tf.reshape(x, [-1, 28, 28, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FC4B3C8>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FC4B3C8>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FC4B3C8>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FC4B3C8>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('conv1'):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "        x_image, 6, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FC4B048>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FC4B048>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FC4B048>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FC4B048>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('pool1'):\n",
    "    S2 = tf.contrib.slim.max_pool2d(C1, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FCEB808>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FCEB808>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FCEB808>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Conv.call of <tensorflow.python.layers.convolutional.Conv2D object at 0x000001EA0FCEB808>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('conv2'):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "        S2, 16, [5, 5], padding='VALID', activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FCDF888>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FCDF888>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FCDF888>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Pooling2D.call of <tensorflow.python.layers.pooling.MaxPooling2D object at 0x000001EA0FCDF888>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('pool2'):\n",
    "    S4 = tf.contrib.slim.max_pool2d(C3, [2, 2], stride=[2, 2], padding='VALID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\contrib\\layers\\python\\layers\\layers.py:1634: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n",
      "WARNING:tensorflow:Entity <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x000001EA0FD55488>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x000001EA0FD55488>>: AttributeError: module 'gast' has no attribute 'Num'\n",
      "WARNING: Entity <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x000001EA0FD55488>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Flatten.call of <tensorflow.python.layers.core.Flatten object at 0x000001EA0FD55488>>: AttributeError: module 'gast' has no attribute 'Num'\n",
      "WARNING:tensorflow:Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FD20F08>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FD20F08>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FD20F08>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FD20F08>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING:tensorflow:Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC48A48>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC48A48>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC48A48>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC48A48>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('fc1'):\n",
    "    S4_flat = tf.contrib.slim.flatten(S4)\n",
    "    C5 = tf.contrib.slim.fully_connected(\n",
    "        S4_flat, 120, activation_fn=tf.nn.relu)\n",
    "\n",
    "with tf.name_scope('fc2'):\n",
    "    F6 = tf.contrib.slim.fully_connected(C5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1  对特征添加一个0.6的dropout，以40%的概率丢弃特征中的某些数据，\n",
    "这样可以提高网络的推广能力，减少过拟合的可能性。\n",
    "\n",
    "需要注意的是，dropout仅在训练的时候使用，验证的时候，需要关闭dropout， 所以验证时候的keep_prob是1.0。\n",
    "\n",
    "dropout的输出最终送入一个隐层为10的全连接层，这个全连接层即为最后的分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-17-413a88f1eb86>:3: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC7E4C8>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC7E4C8>>: AssertionError: Bad argument number for Name: 3, expecting 4\n",
      "WARNING: Entity <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC7E4C8>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method Dense.call of <tensorflow.python.layers.core.Dense object at 0x000001EA0FC7E4C8>>: AssertionError: Bad argument number for Name: 3, expecting 4\n"
     ]
    }
   ],
   "source": [
    "with tf.name_scope('dropout'):\n",
    "    keep_prob = tf.placeholder(name='keep_prob', dtype=tf.float32)\n",
    "    F6_drop = tf.nn.dropout(F6, keep_prob)\n",
    "\n",
    "with tf.name_scope('fc3'):\n",
    "    logits = tf.contrib.slim.fully_connected(F6_drop, 10, activation_fn=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-18-3c77ec77605a>:2: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n",
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(\n",
    "    tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))\n",
    "\n",
    "l2_loss = tf.add_n([\n",
    "    tf.nn.l2_loss(w)\n",
    "    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n",
    "])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES):\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "tf.summary.scalar('cross_entropy_loss', cross_entropy_loss)\n",
    "tf.summary.scalar('l2_loss', l2_loss)\n",
    "tf.summary.scalar('total_loss', total_loss)\n",
    "\n",
    "optimizer = tf.train.GradientDescentOptimizer(\n",
    "    learning_rate=0.3).minimize(total_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, 1), tf.argmax(logits, 1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 100\n",
    "trainig_step = 1100\n",
    "\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after 100 training steps, the loss is 0.456346, the validation accuracy is 0.9064\n",
      "after 200 training steps, the loss is 0.220315, the validation accuracy is 0.9418\n",
      "after 300 training steps, the loss is 0.159415, the validation accuracy is 0.9576\n",
      "after 400 training steps, the loss is 0.0880476, the validation accuracy is 0.9664\n",
      "after 500 training steps, the loss is 0.153092, the validation accuracy is 0.9692\n",
      "after 600 training steps, the loss is 0.0856823, the validation accuracy is 0.9774\n",
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:960: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "after 700 training steps, the loss is 0.143915, the validation accuracy is 0.9708\n",
      "after 800 training steps, the loss is 0.0925228, the validation accuracy is 0.9804\n",
      "after 900 training steps, the loss is 0.0858938, the validation accuracy is 0.9814\n",
      "after 1000 training steps, the loss is 0.105037, the validation accuracy is 0.9808\n",
      "the training is finish!\n",
      "the test accuarcy is: 0.9831\n"
     ]
    }
   ],
   "source": [
    "merged = tf.summary.merge_all()\n",
    "with tf.Session() as sess:\n",
    "\n",
    "    writer = tf.summary.FileWriter(\"logs/\", sess.graph)\n",
    "\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    #定义验证集与测试集\n",
    "    validate_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0}\n",
    "\n",
    "    for i in range(trainig_step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, cross_entropy_loss, merged],\n",
    "            feed_dict={\n",
    "                x: xs,\n",
    "                y: ys,\n",
    "                keep_prob: 0.6\n",
    "            })\n",
    "        writer.add_summary(rs, i)\n",
    "\n",
    "        #每100次训练打印一次损失值与验证准确率\n",
    "        if i > 0 and i % 100 == 0:\n",
    "            validate_accuracy = sess.run(accuracy, feed_dict=validate_data)\n",
    "            print(\n",
    "                \"after %d training steps, the loss is %g, the validation accuracy is %g\"\n",
    "                % (i, loss, validate_accuracy))\n",
    "            saver.save(sess, './model.ckpt', global_step=i)\n",
    "\n",
    "    print(\"the training is finish!\")\n",
    "    #最终的测试准确率\n",
    "    acc = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"the test accuarcy is:\", acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From D:\\Anaconda\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1276: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model.ckpt-1000\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state('./')\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "            [pred, accuracy],\n",
    "            feed_dict={\n",
    "                x: mnist.test.images[:16],\n",
    "                y: mnist.test.labels[:16],\n",
    "                keep_prob: 1.0\n",
    "            })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis('off')\n",
    "            plt.title('{}: [{}]-[{:.1f}%]'.format(\n",
    "                np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape((28, 28)))\n",
    "\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积的特性描述:\n",
    "卷积就是将二元函数 U(x,y)=f(x)g(y) 卷成一元函数 V(t),具有线性性（filter(f1+f2)=filter(f1)+filter(f2\n",
    ")），移不变性（filter(shift(f)) = shift(filter(f))）和任何线性移不变的算子（操作）都可视为一种卷积操作；\n",
    "卷积在图像视觉中实质就是滤波器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积与全连接网络对比：\n",
    "1.卷积的神经元只与上层一部分神经元相连，减少了参数\n",
    "2.卷积的一组参数可以共享一个权重，有效利用图像像素之间的关系\n",
    "3.卷积可以使用Pooling来减少每层的样本数，进一步减少参数数量，同时还可以提升模型的鲁棒性\n",
    "4.全连接由于梯度下降法，导致层数不能过高"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
